const express = require('express');
const fs = require('fs');
const path = require('path');
const net = require('net');
const axios = require('axios');
const cors = require('cors');
const app = express();

// 中间件设置
app.use(express.json());
app.use(express.static('.'));
app.use(cors());

// 检查端口是否可用
async function isPortAvailable(port) {
    return new Promise((resolve) => {
        const server = net.createServer();
        server.once('error', () => {
            resolve(false);
        });
        server.once('listening', () => {
            server.close();
            resolve(true);
        });
        server.listen(port);
    });
}

// 查找可用端口
async function findAvailablePort(startPort) {
    const net = require('net');
    return new Promise((resolve, reject) => {
        const server = net.createServer();
        server.unref();
        server.on('error', (err) => {
            if (err.code === 'EADDRINUSE') {
                resolve(findAvailablePort(startPort + 1));
            } else {
                reject(err);
            }
        });
        server.listen(startPort, () => {
            const port = server.address().port;
            server.close(() => resolve(port));
        });
    });
}

// 确保工作目录存在
async function ensureStorageDir() {
    try {
        await fs.promises.mkdir(path.join(__dirname, 'storage'), { recursive: true });
    } catch (error) {
        console.error('创建storage目录失败:', error);
    }
}

// 保存页面内容
app.post('/save-page', async (req, res) => {
    try {
        // 确保storage目录存在
        await ensureStorageDir();
        
        const { pageId, content } = req.body;
        if (!pageId || !content) {
            return res.status(400).send('缺少必要参数');
        }

        const filePath = path.join(__dirname, 'storage', `${pageId}.html`);
        
        // 确保内容不为空再保存
        if (content.trim()) {
            await fs.promises.writeFile(filePath, content, 'utf8');
            console.log(`成功保存文件: ${filePath}`);
            res.status(200).send('保存成功');
        } else {
            res.status(400).send('内容不能为空');
        }
    } catch (error) {
        console.error('保存文件失败:', error);
        res.status(500).send('保存失败');
    }
});

// 加载页面内容
app.get('/load-page/:pageId', async (req, res) => {
    try {
        const { pageId } = req.params;
        if (!pageId) {
            return res.status(400).send('');
        }

        const filePath = path.join(__dirname, 'storage', `${pageId}.html`);
        
        try {
            const stats = await fs.promises.stat(filePath);
            if (stats.size === 0) {
                console.log(`文件存在但为空: ${filePath}`);
                return res.send('');
            }
            
            const content = await fs.promises.readFile(filePath, 'utf8');
            if (!content.trim()) {
                console.log(`文件内容为空: ${filePath}`);
                return res.send('');
            }
            
            console.log(`成功读取文件: ${filePath}`);
            res.send(content);
        } catch (error) {
            if (error.code === 'ENOENT') {
                console.log(`文件不存在: ${filePath}`);
                return res.send('');
            }
            throw error;
        }
    } catch (error) {
        console.error('读取文件失败:', error);
        res.send('');
    }
});

// 保存页面结构元数据
app.post('/save-metadata', async (req, res) => {
    try {
        await ensureStorageDir();
        
        const { data } = req.body;
        if (!data) {
            return res.status(400).send('缺少必要参数');
        }
        
        const filePath = path.join(__dirname, 'storage', 'metadata.json');
        
        await fs.promises.writeFile(filePath, data, 'utf8');
        console.log(`成功保存页面结构元数据: ${filePath}`);
        res.status(200).send('保存成功');
    } catch (error) {
        console.error('保存页面结构元数据失败:', error);
        res.status(500).send('保存失败');
    }
});

// 加载页面结构元数据
app.get('/load-metadata', async (req, res) => {
    try {
        const filePath = path.join(__dirname, 'storage', 'metadata.json');
        
        try {
            await fs.promises.access(filePath);
            const data = await fs.promises.readFile(filePath, 'utf8');
            console.log(`成功读取页面结构元数据: ${filePath}`);
            res.send(data);
        } catch (error) {
            if (error.code === 'ENOENT') {
                console.log(`页面结构元数据文件不存在: ${filePath}`);
                return res.status(404).send('');
            }
            throw error;
        }
    } catch (error) {
        console.error('读取页面结构元数据失败:', error);
        res.status(500).send('');
    }
});

// API代理路由
app.post('/api/proxy', async (req, res) => {
    console.log('收到API代理请求', req.query);
    
    try {
        // 从请求体中获取模型信息
        const requestBody = req.body;
        const modelName = requestBody.model || (requestBody.input && requestBody.input.model);
        const isStreamRequest = requestBody.stream === true;
        
        console.log('代理请求模型:', modelName);
        console.log('是否为流式请求:', isStreamRequest);
        console.log('请求头:', JSON.stringify(req.headers, null, 2));
        console.log('请求体:', JSON.stringify(requestBody, null, 2).substring(0, 500) + '...');
        
        // 获取API密钥
        const authHeader = req.headers['authorization'];
        if (!authHeader) {
            console.error('缺少Authorization头');
            return res.status(401).json({ error: '缺少API密钥' });
        }
        
        // 确定正确的API端点
        let targetUrl = 'https://dashscope.aliyuncs.com/compatible-mode/v1';
        
        // 特殊处理QWQ-32B模型
        if (modelName === 'qwq-32b') {
            targetUrl = 'https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions';
            console.log('使用QWQ-32B专用端点');
        }
        
        console.log('转发请求到:', targetUrl);
        
        // 流式请求需要特殊处理
        if (isStreamRequest && modelName === 'qwq-32b') {
            console.log('处理QWQ-32B流式请求');
            
            // 设置响应头
            res.writeHead(200, {
                'Content-Type': 'application/json',
                'Transfer-Encoding': 'chunked'
            });
            
            try {
                // 创建流式请求
                const axiosResponse = await axios({
                    method: 'post',
                    url: targetUrl,
                    headers: {
                        'Content-Type': 'application/json',
                        'Authorization': authHeader,
                        'Accept': 'application/json'
                    },
                    data: requestBody,
                    responseType: 'stream'
                });
                
                // 转发流数据到客户端
                axiosResponse.data.on('data', (chunk) => {
                    console.log('收到流数据片段，长度:', chunk.length);
                    try {
                        // 直接转发原始数据
                        res.write(chunk);
                    } catch (err) {
                        console.error('写入流数据出错:', err);
                    }
                });
                
                axiosResponse.data.on('end', () => {
                    console.log('流数据传输完成');
                    res.end();
                });
                
                axiosResponse.data.on('error', (err) => {
                    console.error('流数据传输错误:', err);
                    // 尝试发送错误信息
                    try {
                        res.end(JSON.stringify({
                            error: '流数据传输错误',
                            message: err.message
                        }));
                    } catch (endErr) {
                        console.error('无法发送错误响应:', endErr);
                    }
                });
            } catch (streamError) {
                console.error('流式请求错误:', streamError);
                // 尝试发送错误信息
                try {
                    if (!res.headersSent) {
                        res.writeHead(500, { 'Content-Type': 'application/json' });
                    }
                    res.end(JSON.stringify({
                        error: '流式请求错误',
                        message: streamError.message,
                        details: streamError.response?.data
                    }));
                } catch (endErr) {
                    console.error('无法发送错误响应:', endErr);
                }
            }
            
            // 流式处理会在stream事件处理中结束响应，不需要继续执行
            return;
        }
        
        // 非流式请求的处理
        const apiResponse = await axios({
            method: 'post',
            url: targetUrl,
            headers: {
                'Content-Type': 'application/json',
                'Authorization': authHeader
            },
            data: requestBody,
            validateStatus: () => true, // 允许任何状态码
            maxBodyLength: Infinity,
            maxContentLength: Infinity
        });
        
        console.log('API响应状态:', apiResponse.status);
        console.log('API响应头:', JSON.stringify(apiResponse.headers, null, 2));
        
        // 如果响应不成功，记录详细错误信息
        if (apiResponse.status !== 200) {
            console.error('API请求失败, 状态码:', apiResponse.status);
            console.error('错误响应:', JSON.stringify(apiResponse.data, null, 2));
            
            // 将API错误直接转发给客户端
            return res.status(apiResponse.status).json({
                error: '上游API请求失败',
                status: apiResponse.status,
                statusText: apiResponse.statusText,
                apiResponse: apiResponse.data
            });
        }
        
        // 处理成功响应
        console.log('API响应成功, 响应大小:', JSON.stringify(apiResponse.data).length);
        
        // 返回结果
        res.status(apiResponse.status).json(apiResponse.data);
    } catch (error) {
        console.error('代理请求错误:', error.message);
        if (error.response) {
            console.error('上游服务器响应:', error.response.status, error.response.statusText);
            console.error('响应数据:', JSON.stringify(error.response.data, null, 2));
            res.status(error.response.status).json({
                error: '上游API响应错误',
                details: error.response.data,
                message: error.message
            });
        } else if (error.request) {
            console.error('未收到响应的请求:', error.request);
            res.status(500).json({
                error: '未收到API响应',
                message: error.message
            });
        } else {
            console.error('请求配置错误:', error.message);
            res.status(500).json({
                error: '代理请求配置错误',
                message: error.message
            });
        }
    }
});

// 在路由之后添加全局错误处理中间件
app.use((err, req, res, next) => {
    console.error('全局错误:', err);
    res.status(500).json({
        error: err.message,
        code: err.code || 'UNKNOWN_ERROR'
    });
});

// 启动服务器
async function startServer() {
    try {
        const port = await findAvailablePort(3000);
        const server = app.listen(port, () => {
            console.log(`\n服务器运行在 http://localhost:${port}`);
            console.log(`存储目录: ${path.join(__dirname, 'storage')}`);
            
            // 确保文件写入安全
            try {
                fs.writeFileSync(
                    path.join(__dirname, 'server-config.json'),
                    JSON.stringify({ port }),
                    'utf8'
                );
            } catch (writeErr) {
                console.error('写入配置文件失败:', writeErr);
            }
        });

        // 增强错误处理
        server.on('error', (err) => {
            if (err.code === 'EADDRINUSE') {
                console.error(`端口 ${port} 已被占用，尝试其他端口...`);
                startServer();
            } else {
                console.error('服务器错误:', err);
            }
        });

        // 处理进程退出
        process.on('SIGINT', () => {
            console.log('\n正在关闭服务器...');
            server.close(() => {
                console.log('服务器已安全关闭');
                process.exit(0);
            });
        });
    } catch (err) {
        console.error('启动服务器失败:', err);
        process.exit(1);
    }
}

startServer(); 